JUC学习 二

一、闭锁：java.util.concurrent.CountDownLatch
1、CountDownLatch是一个同步辅助类，在完成一组正在其他线程执行的操作之前，可以使一个、或多个线程处于等待状态。
2、闭锁可以延缓线程的进度直至到达终点状态，可以确保某些活动在其他活动完成后才执行：
确保某个计算在它所需要的资源都初始化后才继续执行；
确保某个服务在其依赖的其他服务都启动后才启动；
等待直到某个操作的参与者都准备就绪后才开始执行；

例子：直到10个线程都执行完毕在算最后的时间差。（每执行完一个线程，countDown计数减一。）

---

CountDownLatch latch=new CountDownLatch(10); //创建对象
        long start=System.currentTimeMillis();
        for(int i=0;i<10;i++)
        new Thread(()->{
            try {
                for (int j = 0; j < 1000; j++)
                    System.out.println(j);
            }finally {
                latch.countDown(); //计数减1
            }
        }).start();
        try {
            latch.await();  //计数不为0则始终等待
        }catch(InterruptedException e){}
        long end=System.currentTimeMillis();
        System.out.println("耗费时间："+(end-start));

二、创建线程的第三种方式： Callable 接口（可带泛型）
1、call方法具有返回值： 类型 call(){ return 类型值}；
2、执行Callable的线程，需要FutureTask 类的支持，用来接收返回值；

例子：

 public static void main(String[] args) {

        Test t=new Test();
        FutureTask<Integer> task=new FutureTask<Integer>(t);  
        new Thread(task).start();

        new Thread(()->{
            try {
                System.out.println("last:" + (task.get() + 10));   //get（）方法取出返回值
            }catch(Exception e){}
        }).start();
    }

    static class Test implements Callable<Integer>{         //实现Callable接口
        public Integer call() throws Exception{          //call方法会抛出异常
             int sum=0;
            for(int i=0;i<100;i++) {
                sum += i;
                System.out.println("sum:"+sum);
            }
            return sum;
        }
    }